import type { Router } from 'vue-router';

import { DEFAULT_HOME_PATH, LOGIN_PATH, getDefaultHomePath } from '@vben/constants';
import { preferences } from '@vben/preferences';
import { useAccessStore, useUserStore } from '@vben/stores';
import { startProgress, stopProgress } from '@vben/utils';

import { accessRoutes, coreRouteNames } from '#/router/routes';
import { useAuthStore } from '#/store';

import { generateAccess } from './access';

/**
 * 通用守卫配置
 * @param router
 */
function setupCommonGuard(router: Router) {
  // 记录已经加载的页面
  const loadedPaths = new Set<string>();

  router.beforeEach(async (to) => {
    console.log('to', to);
    to.meta.loaded = loadedPaths.has(to.path);

    // 页面加载进度条
    if (!to.meta.loaded && preferences.transition.progress) {
      startProgress();
    }
    return true;
  });

  router.afterEach((to) => {
    // 记录页面是否加载,如果已经加载，后续的页面切换动画等效果不在重复执行

    loadedPaths.add(to.path);

    // 关闭页面加载进度条
    if (preferences.transition.progress) {
      stopProgress();
    }
  });
}

/**
 * 权限访问守卫配置
 * @param router
 */
function setupAccessGuard(router: Router) {
  router.beforeEach(async (to, from) => {
    const accessStore = useAccessStore();
    // const userStore = useUserStore(); // 这里暂时没有用到用户信息
    const authStore = useAuthStore();

    // 基本路由，这些路由不需要进入权限拦截
    if (coreRouteNames.includes(to.name as string)) {
      if (to.path === LOGIN_PATH && accessStore.accessToken) {
        // 如果有重定向参数，优先使用重定向路径
        if (to.query?.redirect) {
          return decodeURIComponent(to.query.redirect as string);
        }
        
        // 使用动态获取的首页路径，如果accessRoutes为空则使用默认路径
        const homePath = getDefaultHomePath(accessStore.accessRoutes);
        return homePath || DEFAULT_HOME_PATH;
      }
      return true;
    }

    // accessToken 检查
    if (!accessStore.accessToken) {
      // 明确声明忽略权限访问权限，则可以访问
      if (to.meta.ignoreAccess) {
        return true;
      }

      // 没有访问权限，跳转登录页面
      if (to.fullPath !== LOGIN_PATH) {
        return {
          path: LOGIN_PATH,
          // 如不需要，直接删除 query
          query: {
            // 如果当前路径是首页，则不需要重定向
            ...(to.fullPath === DEFAULT_HOME_PATH ? {} : { redirect: encodeURIComponent(to.fullPath) })
          },
          // 携带当前跳转的页面，登录后重新跳转该页面
          replace: true,
        };
      }
      return to;
    }

    // 是否已经生成过动态路由
    if (accessStore.isAccessChecked) {
      return true;
    }

    // 生成路由表
    // 当前登录用户拥有的角色标识列表
    // 暂时没有获取到用户信息，所以这里暂时没有做处理，路由表直接使用默认路由表
    // const userInfo = userStore.userInfo || (await authStore.fetchUserInfo());
    // const userRoles = userInfo.roles ?? [];

    // 生成菜单和路由
    const { accessibleMenus, accessibleRoutes } = await generateAccess({
      // roles: userRoles,  //权限标识
      roles: [], // 传空数组跳过权限过滤
      router,
      // 则会在菜单中显示，但是访问会被重定向到403
      routes: accessRoutes,
    });

    // 保存菜单信息和路由信息
    accessStore.setAccessMenus(accessibleMenus);
    accessStore.setAccessRoutes(accessibleRoutes);
    accessStore.setIsAccessChecked(true);
    
    // 动态设置根路由的重定向路径
    const rootRoute = router.getRoutes().find(route => route.name === 'Root');
    if (rootRoute) {
      const dynamicHomePath = getDefaultHomePath(accessibleRoutes);
      console.log('Current root redirect:', rootRoute.redirect, 'Dynamic home path:', dynamicHomePath);
      
      if (dynamicHomePath && dynamicHomePath !== rootRoute.redirect) {
        try {
          // 移除旧的根路由
          router.removeRoute('Root');
          
          // 添加新的根路由，使用动态获取的首页路径
          router.addRoute({
            ...rootRoute,
            redirect: dynamicHomePath,
            children: rootRoute.children
          });
          
          console.log('Root route redirect updated to:', dynamicHomePath);
        } catch (error) {
          console.error('Failed to update root route redirect:', error);
        }
      }
    }
    // 路由权限检查
    // const redirectPath = (from.query.redirect ??
    //   (to.path === DEFAULT_HOME_PATH
    //     ? userInfo.homePath || DEFAULT_HOME_PATH
    //     : to.fullPath)) as string;
    // 跳转到上次访问的页面
    // return {
    //   ...router.resolve(decodeURIComponent(redirectPath)),
    //   replace: true,
    // };

    // 检查是否有重定向参数
    const redirectPath = from.query.redirect as string;
    if (redirectPath) {
      return {
        ...router.resolve(decodeURIComponent(redirectPath)),
        replace: true,
      };
    }
    
    // 直接跳转动态获取的首页
    const homePath = getDefaultHomePath(accessibleRoutes) || DEFAULT_HOME_PATH;
    return {
      ...router.resolve(homePath),
      replace: true,
    };
  });
}

/**
 * 项目守卫配置
 * @param router
 */
function createRouterGuard(router: Router) {
  /** 通用 */
  setupCommonGuard(router);
  /** 权限访问 */
  setupAccessGuard(router);
}

export { createRouterGuard };
